const path = require('path');
const fs = require('fs');
const cosUploader = require('./cosUploader');

/**
 * 构建上传管理器
 * 提供构建后上传的统一接口和管理功能
 */
class BuildUploader {
  constructor() {
    this.config = {
      enabled: process.env.BUILD_UPLOAD_ENABLED !== 'false', // 默认启用
      autoCleanup: process.env.BUILD_AUTO_CLEANUP !== 'false', // 默认启用自动清理
      maxVersions: parseInt(process.env.BUILD_MAX_VERSIONS) || 10,
      uploadLogs: process.env.BUILD_UPLOAD_LOGS !== 'false' // 默认启用日志
    };
  }

  /**
   * 检查是否启用上传功能
   * @returns {boolean} 是否启用
   */
  isEnabled() {
    return this.config.enabled;
  }

  /**
   * 获取构建配置
   * @returns {Object} 配置对象
   */
  getConfig() {
    return { ...this.config };
  }

  /**
   * 更新构建配置
   * @param {Object} newConfig 新配置
   */
  updateConfig(newConfig) {
    this.config = { ...this.config, ...newConfig };
  }

  /**
   * 执行构建后上传
   * @param {Object} options 上传选项
   * @returns {Promise<Object>} 上传结果
   */
  async executeBuildUpload(options = {}) {
    if (!this.isEnabled()) {
      console.log('构建上传功能已禁用，跳过上传');
      return { success: false, reason: 'disabled' };
    }

    try {
      console.log('=== 执行构建后上传 ===');
      
      // 获取版本信息
      const version = options.version || this.getVersionFromPackage();
      if (!version) {
        throw new Error('无法获取版本信息');
      }

      // 扫描构建产物
      const buildFiles = this.scanBuildFiles();
      if (buildFiles.length === 0) {
        console.log('未找到构建产物，跳过上传');
        return { success: false, reason: 'no_build_files' };
      }

      // 执行上传
      const uploadResults = [];
      for (const filePath of buildFiles) {
        const result = await this.uploadBuildFile(filePath, version);
        uploadResults.push(result);
        
        if (result.success) {
          console.log(`✅ ${path.basename(filePath)} 上传成功`);
        } else {
          console.error(`❌ ${path.basename(filePath)} 上传失败: ${result.error}`);
        }
      }

      // 自动清理旧版本
      if (this.config.autoCleanup) {
        await this.cleanupOldVersions();
      }

      // 生成上传报告
      const report = this.generateUploadReport(uploadResults, version);
      
      console.log('=== 构建后上传完成 ===');
      return { success: true, report, uploadResults };

    } catch (error) {
      console.error('构建后上传执行失败:', error.message);
      return { success: false, error: error.message };
    }
  }

  /**
   * 从package.json获取版本信息
   * @returns {string} 版本号
   */
  getVersionFromPackage() {
    try {
      const packagePath = path.join(__dirname, '../package.json');
      if (fs.existsSync(packagePath)) {
        const packageData = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
        return packageData.version;
      }
    } catch (error) {
      console.error('读取package.json失败:', error.message);
    }
    return null;
  }

  /**
   * 扫描构建产物文件
   * @returns {Array} 文件路径列表
   */
  scanBuildFiles() {
    const distPath = path.join(__dirname, '../dist');
    
    if (!fs.existsSync(distPath)) {
      return [];
    }

    try {
      const files = fs.readdirSync(distPath);
      return files
        .filter(file => {
          // 过滤条件：exe文件，包含Whistle，排除blockmap
          return file.endsWith('.exe') && 
                 file.includes('Whistle') && 
                 !file.includes('.blockmap');
        })
        .map(file => path.join(distPath, file));
    } catch (error) {
      console.error('扫描构建产物失败:', error.message);
      return [];
    }
  }

  /**
   * 上传单个构建文件
   * @param {string} filePath 文件路径
   * @param {string} version 版本号
   * @returns {Promise<Object>} 上传结果
   */
  async uploadBuildFile(filePath, version) {
    try {
      // 检查文件是否已存在
      const exists = await cosUploader.fileExists(version);
      if (exists) {
        return {
          success: false,
          reason: 'already_exists',
          message: `版本 ${version} 已存在`
        };
      }

      // 执行上传
      const result = await cosUploader.uploadExeFile(filePath, version);
      
      // 记录日志
      if (this.config.uploadLogs) {
        this.logUploadResult(result, filePath, version);
      }

      return result;
    } catch (error) {
      return {
        success: false,
        error: error.message
      };
    }
  }

  /**
   * 清理旧版本
   * @returns {Promise<number>} 删除的文件数量
   */
  async cleanupOldVersions() {
    try {
      console.log('开始清理旧版本...');
      const deletedCount = await cosUploader.deleteOldVersions(this.config.maxVersions);
      
      if (deletedCount > 0) {
        console.log(`清理完成，删除了 ${deletedCount} 个旧版本`);
      } else {
        console.log('无需清理，版本数量在限制范围内');
      }
      
      return deletedCount;
    } catch (error) {
      console.error('清理旧版本失败:', error.message);
      return 0;
    }
  }

  /**
   * 记录上传日志
   * @param {Object} result 上传结果
   * @param {string} filePath 文件路径
   * @param {string} version 版本号
   */
  logUploadResult(result, filePath, version) {
    try {
      const logPath = path.join(__dirname, '../upload-logs');
      if (!fs.existsSync(logPath)) {
        fs.mkdirSync(logPath, { recursive: true });
      }

      const logFile = path.join(logPath, `build-upload-${new Date().toISOString().split('T')[0]}.log`);
      const logEntry = {
        timestamp: new Date().toISOString(),
        fileName: path.basename(filePath),
        version,
        success: result.success,
        url: result.url || '',
        error: result.error || '',
        fileSize: result.fileInfo?.fileSize || 0,
        cloudPath: result.cloudPath || ''
      };

      const logLine = JSON.stringify(logEntry) + '\n';
      fs.appendFileSync(logFile, logLine);
    } catch (error) {
      console.error('写入上传日志失败:', error.message);
    }
  }

  /**
   * 生成上传报告
   * @param {Array} uploadResults 上传结果列表
   * @param {string} version 版本号
   * @returns {Object} 上传报告
   */
  generateUploadReport(uploadResults, version) {
    const totalFiles = uploadResults.length;
    const successCount = uploadResults.filter(r => r.success).length;
    const failedCount = totalFiles - successCount;

    return {
      version,
      timestamp: new Date().toISOString(),
      summary: {
        totalFiles,
        successCount,
        failedCount,
        successRate: totalFiles > 0 ? (successCount / totalFiles * 100).toFixed(2) + '%' : '0%'
      },
      details: uploadResults
    };
  }

  /**
   * 获取已上传的版本列表
   * @returns {Promise<Array>} 版本列表
   */
  async getUploadedVersions() {
    try {
      return await cosUploader.listUploadedVersions();
    } catch (error) {
      console.error('获取已上传版本失败:', error.message);
      return [];
    }
  }

  /**
   * 检查特定版本是否已上传
   * @param {string} version 版本号
   * @returns {Promise<boolean>} 是否已上传
   */
  async isVersionUploaded(version) {
    try {
      return await cosUploader.fileExists(version);
    } catch (error) {
      console.error('检查版本上传状态失败:', error.message);
      return false;
    }
  }
}

// 创建单例实例
const buildUploader = new BuildUploader();

module.exports = buildUploader;
